import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class demo {
    // 乒乓球筐▲ (注意)在hashMap中方法  containsKey()写法
//    nowcoder有两盒（A、B）乒乓球，有红双喜的、有亚力亚的……现在他需要判别A盒是否包含了B盒中所有的种类，
//    并且每种球的数量不少于B盒中的数量，该怎么办呢？
//  输入描述:
//输入有多组数据。
//每组数据包含两个字符串A、B，代表A盒与B盒中的乒乓球，每个乒乓球用一个大写字母表示，即相同类型的乒乓球为相同的大写字母。
//字符串长度不大于10000。
//  输出描述:
//每一组输入对应一行输出：如果B盒中所有球的类型在A中都有，并且每种球的数量都不大于A，则输出“Yes”；否则输出“No”。
//  输入
//ABCDFYE CDE
//ABCDGEAS CDECDE
//  输出
//Yes
//No

    //    思路
//借助 map 统计出每个盒子中的每种球的类别和数目. 然后遍历其中的一个 map 和另外一个 map 进行对比即
    public static void main1(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            String strA = sc.next();
            String strB = sc.next();
            Map<Character,Integer> mapA = new HashMap<>();
            Map<Character,Integer> mapB = new HashMap<>();

            // 转换成字符数组 方便后面调用
            char[] chA = strA.toCharArray();
            char[] chB = strB.toCharArray();

            // 计数
            // 对mapA
            for (int i=0; i<chA.length; i++) {
                if (mapA.containsKey(chA[i])) {
                    mapA.put(chA[i], mapA.get(chA[i])+1);
                }else {
                    mapA.put(chA[i], 1);
                }
            }
            // 对mapB
            for (int i=0; i<chB.length; i++) {
                if (mapB.containsKey(chB[i])) {
                    mapB.put(chB[i], mapB.get(chB[i])+1);
                }else {
                    mapB.put(chB[i], 1);
                }
            }

            // 标记 判断
            boolean flag = true;

            // 遍历字符数组chB 判断 是否有不满足 盒中所有球的类型在A中都有，并且每种球的数量都不大于A
            for (char ch : chB) {
                if (!mapA.containsKey(ch) || mapA.get(ch)<mapB.get(ch)) {
                    flag = false;
                    break;
                }
            }

            if (flag) {
                System.out.println("Yes");
            }else {
                System.out.println("No");
            }
        }
    }



    // 查找兄弟单词▲▲▲
//定义一个单词的“兄弟单词”为：交换该单词字母顺序（注：可以交换任意次），而不添加、删除、修改原有的字母就能生成的单词。
//兄弟单词要求和原来的单词不同。例如： ab 和 ba 是兄弟单词。 ab 和 ab 则不是兄弟单词。
//现在给定你 n 个单词，另外再给你一个单词 x ，让你寻找 x 的兄弟单词里，按字典序排列后的第 k 个单词是什么？
//注意：字典中可能有重复单词。
//输入描述:
//输入只有一行。
//先输入字典中单词的个数n，再输入n个单词作为字典单词。
//然后输入一个单词x
//最后后输入一个整数k
//输出描述:
//第一行输出查找到x的兄弟单词的个数m
//第二行输出查找到的按照字典顺序排序后的第k个兄弟单词，没有符合第k个的话则不用输出

//输入
//3 abc bca cab abc 1
//输出
//2
//bca

//输入
//6 cab ad abcd cba abc bca abc 1
//输出
//3
//bca

//    思路:
//1. 将字典中的单词先放到 vector 中
//2. 将 vector 进行排序
//3. isBrother 函数依次判定每个输入的单词是否是兄弟单词
//4. 判定兄弟单词的规则是△
//      1. 先判定长度
//      2. 如果长度相同, 再看是否是完全相同(完全相同不算兄弟)
//      3. 然后将两个单词排序, 排序相同才是真兄弟单词.

    public static boolean isBrothWord (String strA, String strB) {
        // 1. 先判定长度
        if (strA.length() != strB.length()) {
            return false;
        }

        // 2. 如果长度相同, 再看是否是完全相同(完全相同不算兄弟)
        if (strA.equals(strB)) {
            return false;
        }

        // 3. 然后将两个单词排序, 排序相同才是真兄弟单词.

//        Arrays.sort(str);err 怎么可以对字符串排序呢
        // 先将字符串转换成字符再排序
        char[] chA = strA.toCharArray();
        char[] chB = strB.toCharArray();
        Arrays.sort(chA);
        Arrays.sort(chB);
        // 再将字符 转换成字符串 比较是否相同
        strA = new String(chA);
        strB = new String(chB);
        if (!strA.equals(strB)) {
            return false;
        }
        return true;
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            // 获取数据
            int n = sc.nextInt();
            String[] arr = new String[n];
            for (int i=0; i<n; i++) {
                arr[i] = sc.next();
            }
            String cur = sc.next();
            int k = sc.nextInt();

            // 要先对arr数组进行字典排序 因为 题目要求  按字典序排列后的第 k 个单词是什么
            Arrays.sort(arr); // 排序是Arrays  末尾有加s的

            // 记录兄弟单词的个数
            int brothWordCount = 0;

            // 保存第 k 个单词是什么
            String kBroth = "";
            for (int i=0; i<n; i++) {
                if (isBrothWord(arr[i], cur)) {
                    brothWordCount++;
                    if (brothWordCount == k) {
                        kBroth = arr[i];
                    }
                }
            }
            System.out.println(brothWordCount);

//            这里还要判断 k那位置的兄弟单词 需不需要打印
            if (brothWordCount >= k) {
                System.out.println(kBroth);
            }

        }
    }
}
